{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6384\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append('../')\n",
    "from data_read import *\n",
    "from net import *\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import argparse\n",
    "\n",
    "import os\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "\n",
    "\n",
    "parser.add_argument('--dataset_name', action=\"store\", dest= \"dataset_name\",default=\"MSCOCO\",help='MSCOCO,GoogleMap,GoogleEarth,DayNight')\n",
    "\n",
    "\n",
    "parser.add_argument('--epoch_load_one', action=\"store\", dest=\"epoch_load_one\", type=int, default=3,help='epoch_load_one')\n",
    "\n",
    "\n",
    "parser.add_argument('--epoch_load_two', action=\"store\", dest=\"epoch_load_two\", type=int, default=3,help='epoch_load_two')\n",
    "\n",
    "parser.add_argument('--epoch_load_three', action=\"store\", dest=\"epoch_load_three\", type=int, default=3,help='epoch_load_three')\n",
    "\n",
    "parser.add_argument('--num_iters', action=\"store\", dest=\"num_iters\", type=int, default=20,help='num_iters')\n",
    "\n",
    "parser.add_argument('--feature_map_type', action=\"store\", dest=\"feature_map_type\", default='special',help='regular or special')\n",
    "\n",
    "parser.add_argument('--initial_type', action=\"store\", dest=\"initial_type\", default='multi_net',help='vanilla, simple_net, multi_net')\n",
    "\n",
    "parser.add_argument('--load_epoch_simplenet', action=\"store\", dest=\"load_epoch_simplenet\", default=50,help='load_epoch_simplenet')\n",
    "\n",
    "parser.add_argument('--load_epoch_multinet', action=\"store\", dest=\"load_epoch_multinet\", default=[50,50,40],help='load_epoch_multinet')\n",
    "\n",
    "\n",
    "input_parameters = parser.parse_args([])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "  # Restrict TensorFlow to only allocate 1GB of memory on the first GPU\n",
    "  try:\n",
    "    tf.config.experimental.set_virtual_device_configuration(\n",
    "        gpus[0],\n",
    "        [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4000)])\n",
    "    logical_gpus = tf.config.experimental.list_logical_devices('GPU')\n",
    "    print(len(gpus), \"Physical GPUs,\", len(logical_gpus), \"Logical GPUs\")\n",
    "  except RuntimeError as e:\n",
    "    # Virtual devices must be set before GPUs have been initialized\n",
    "    print(e)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def construct_matrix_regression(batch_size,network_output,network_output_2=[0]):\n",
    "    extra=tf.ones((batch_size,1))\n",
    "    predicted_matrix=tf.concat([network_output,extra],axis=-1)\n",
    "    predicted_matrix=tf.reshape(predicted_matrix,[batch_size,3,3])\n",
    "    if len(np.shape(network_output_2))>1:\n",
    "        predicted_matrix_2=tf.concat([network_output_2,extra],axis=-1)\n",
    "        predicted_matrix_2=tf.reshape(predicted_matrix_2,[batch_size,3,3])\n",
    "    hh_matrix=[]\n",
    "    for i in range(batch_size):\n",
    "        if len(np.shape(network_output_2))>1:\n",
    "            hh_matrix.append(np.linalg.inv(np.dot(predicted_matrix_2[i,:,:],predicted_matrix[i,:,:])))\n",
    "        else:\n",
    "            hh_matrix.append(np.linalg.inv(predicted_matrix[i,:,:]))\n",
    "        #hh_matrix.append(predicted_matrix[i,:,:])\n",
    "    \n",
    "    #return tf.linalg.inv(predicted_matrix+0.0001)\n",
    "    return np.asarray(hh_matrix)\n",
    "\n",
    "def initial_motion_COCO():\n",
    "    # prepare source and target four points\n",
    "    matrix_list=[]\n",
    "    for i in range(1):\n",
    "       \n",
    "        src_points=[[0,0],[127,0],[127,127],[0,127]]\n",
    "\n",
    "        tgt_points=[[32,32],[160,32],[160,160],[32,160]]\n",
    "\n",
    "    \n",
    "        src_points=np.reshape(src_points,[4,1,2])\n",
    "        tgt_points=np.reshape(tgt_points,[4,1,2])\n",
    "\n",
    "        # find homography\n",
    "        h_matrix, status = cv2.findHomography(src_points, tgt_points,0)\n",
    "        matrix_list.append(h_matrix)\n",
    "    return np.asarray(matrix_list).astype(np.float32)\n",
    "\n",
    "\n",
    "def construct_matrix(initial_matrix,scale_factor,batch_size):\n",
    "    #scale_factor size_now/(size to get matrix)\n",
    "    initial_matrix=tf.cast(initial_matrix,dtype=tf.float32)\n",
    "    \n",
    "    scale_matrix=np.eye(3)*scale_factor\n",
    "    scale_matrix[2,2]=1.0\n",
    "    scale_matrix=tf.cast(scale_matrix,dtype=tf.float32)\n",
    "    scale_matrix_inverse=tf.linalg.inv(scale_matrix)\n",
    "\n",
    "    scale_matrix=tf.expand_dims(scale_matrix,axis=0)\n",
    "    scale_matrix=tf.tile(scale_matrix,[batch_size,1,1])\n",
    "\n",
    "    scale_matrix_inverse=tf.expand_dims(scale_matrix_inverse,axis=0)\n",
    "    scale_matrix_inverse=tf.tile(scale_matrix_inverse,[batch_size,1,1])\n",
    "\n",
    "    final_matrix=tf.matmul(tf.matmul(scale_matrix,initial_matrix),scale_matrix_inverse)\n",
    "    return final_matrix\n",
    "\n",
    "\n",
    "\n",
    "def average_cornner_error(batch_size,predicted_matrix,u_list,v_list,top_left_u=0,top_left_v=0,bottom_right_u=127,bottom_right_v=127):\n",
    "    \n",
    "    four_conner=[[top_left_u,top_left_v,1],[bottom_right_u,top_left_v,1],[bottom_right_u,bottom_right_v,1],[top_left_u,bottom_right_v,1]]\n",
    "    four_conner=np.asarray(four_conner)\n",
    "    four_conner=np.transpose(four_conner)\n",
    "    four_conner=np.expand_dims(four_conner,axis=0)\n",
    "    four_conner=np.tile(four_conner,[batch_size,1,1]).astype(np.float32)\n",
    "    \n",
    "    new_four_points=tf.matmul(predicted_matrix,four_conner)\n",
    "    \n",
    "    new_four_points_scale=new_four_points[:,2:,:]\n",
    "    new_four_points= new_four_points/new_four_points_scale\n",
    "    \n",
    "    \n",
    "    u_predict=new_four_points[:,0,:]\n",
    "    v_predict=new_four_points[:,1,:]\n",
    "    \n",
    "    average_conner=tf.reduce_mean(tf.sqrt(tf.math.pow(u_predict-u_list,2)+tf.math.pow(v_predict-v_list,2)))\n",
    "\n",
    "    \n",
    "    \n",
    "    return average_conner\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def calculate_feature_map(input_tensor):\n",
    "    bs,height,width,channel=tf.shape(input_tensor)\n",
    "    path_extracted=tf.image.extract_patches(input_tensor, sizes=(1,3,3,1), strides=(1,1,1,1), rates=(1,1,1,1), padding='SAME')\n",
    "    path_extracted=tf.reshape(path_extracted,(bs,height,width,channel,9))\n",
    "    path_extracted_mean=tf.math.reduce_mean(path_extracted,axis=3,keepdims=True)\n",
    "\n",
    "    #path_extracted_mean=tf.tile(path_extracted_mean,[1,1,1,channel,1])\n",
    "    path_extracted=path_extracted-path_extracted_mean\n",
    "    path_extracted_transpose=tf.transpose(path_extracted,(0,1,2,4,3))\n",
    "    variance_matrix=tf.matmul(path_extracted_transpose,path_extracted)\n",
    "    \n",
    "    tracevalue=tf.linalg.trace(variance_matrix)\n",
    "    row_sum=tf.reduce_sum(variance_matrix,axis=-1)\n",
    "    max_row_sum=tf.math.reduce_max(row_sum,axis=-1)\n",
    "    min_row_sum=tf.math.reduce_min(row_sum,axis=-1)\n",
    "    mimic_ratio=(max_row_sum+min_row_sum)/2.0/tracevalue\n",
    "    \n",
    "    return  tf.expand_dims(mimic_ratio,axis=-1)\n",
    "\n",
    "\n",
    "if input_parameters.feature_map_type=='regular':\n",
    "    load_path_one='./checkpoints/'+input_parameters.dataset_name+'/level_one_regular/'\n",
    "\n",
    "    load_path_two='./checkpoints/'+input_parameters.dataset_name+'/level_two_regular/'\n",
    "\n",
    "    load_path_three='./checkpoints/'+input_parameters.dataset_name+'/level_three_regular/'\n",
    "\n",
    "    level_one_input=ResNet_first_input(if_regular=True)\n",
    "    level_one_template=ResNet_first_template(if_regular=True)\n",
    "    level_two_input=ResNet_second_input(if_regular=True)\n",
    "    level_two_template=ResNet_second_template(if_regular=True)\n",
    "    level_three_input=ResNet_third_input(if_regular=True)\n",
    "    level_three_template=ResNet_third_template(if_regular=True)\n",
    "\n",
    "elif input_parameters.feature_map_type=='special':\n",
    "\n",
    "    load_path_one='./checkpoints/'+input_parameters.dataset_name+'/level_one/'\n",
    "\n",
    "    load_path_two='./checkpoints/'+input_parameters.dataset_name+'/level_two/'\n",
    "\n",
    "    load_path_three='./checkpoints/'+input_parameters.dataset_name+'/level_three/'\n",
    "\n",
    "    level_one_input=ResNet_first_input()\n",
    "    level_one_template=ResNet_first_template()\n",
    "    level_two_input=ResNet_second_input()\n",
    "    level_two_template=ResNet_second_template()\n",
    "    level_three_input=ResNet_third_input()\n",
    "    level_three_template=ResNet_third_template()\n",
    "\n",
    "\n",
    "level_one_input.load_weights(load_path_one + 'epoch_'+str(input_parameters.epoch_load_one)+\"input_full\")\n",
    "\n",
    "level_one_template.load_weights(load_path_one + 'epoch_'+str(input_parameters.epoch_load_one)+\"template_full\")\n",
    "\n",
    "level_two_input.load_weights(load_path_two + 'epoch_'+str(input_parameters.epoch_load_two)+\"input_full\")\n",
    "\n",
    "level_two_template.load_weights(load_path_two  + 'epoch_'+str(input_parameters.epoch_load_two)+\"template_full\")\n",
    "\n",
    "level_three_input.load_weights(load_path_three + 'epoch_'+str(input_parameters.epoch_load_three)+\"input_full\")\n",
    "\n",
    "level_three_template.load_weights(load_path_three  + 'epoch_'+str(input_parameters.epoch_load_three)+\"template_full\")\n",
    "\n",
    "\n",
    "if input_parameters.initial_type=='vanilla':\n",
    "    initial_matrix=initial_motion_COCO()\n",
    "    initial_matrix=construct_matrix(initial_matrix,scale_factor=0.25,batch_size=1)\n",
    "\n",
    "if input_parameters.initial_type=='simple_net':\n",
    "    save_path_regression='./checkpoints/'+input_parameters.dataset_name+'/regression_stage_1/'\n",
    "    regression_network=Net_first()\n",
    "    regression_network.load_weights(save_path_regression + 'epoch_'+str(input_parameters.load_epoch_simplenet))\n",
    "\n",
    "if input_parameters.initial_type=='multi_net':\n",
    "    save_path_one='./checkpoints/'+input_parameters.dataset_name+'/regression_stage_1/'\n",
    "    save_path_two='./checkpoints/'+input_parameters.dataset_name+'/regression_stage_2/'\n",
    "    save_path_three='./checkpoints/'+input_parameters.dataset_name+'/regression_stage_3/'\n",
    "    regression_network_one=Net_first()\n",
    "    regression_network_one.load_weights(save_path_one + 'epoch_'+str(input_parameters.load_epoch_multinet[0]))\n",
    "    regression_network_two=Net_second()\n",
    "    regression_network_two.load_weights(save_path_two + 'epoch_'+str(input_parameters.load_epoch_multinet[1]))\n",
    "    regression_network_three=Net_third()\n",
    "    regression_network_three.load_weights(save_path_three + 'epoch_'+str(input_parameters.load_epoch_multinet[2]))\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "LK_layer_one=Lucas_Kanade_layer(batch_size=1,height_template=128,width_template=128,num_channels=1)\n",
    "\n",
    "LK_layer_two=Lucas_Kanade_layer(batch_size=1,height_template=64,width_template=64,num_channels=1)\n",
    "\n",
    "LK_layer_three=Lucas_Kanade_layer(batch_size=1,height_template=32,width_template=32,num_channels=1)\n",
    "\n",
    "\n",
    "LK_layer_regression=Lucas_Kanade_layer(batch_size=1,height_template=192,width_template=192,num_channels=3)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "if input_parameters.dataset_name=='MSCOCO':\n",
    "    data_loader_caller=data_loader_MSCOCO('val')\n",
    "\n",
    "if input_parameters.dataset_name=='GoogleMap':\n",
    "    data_loader_caller=data_loader_GoogleMap('val')\n",
    "\n",
    "if input_parameters.dataset_name=='GoogleEarth':\n",
    "    data_loader_caller=data_loader_GoogleEarth('val')\n",
    "\n",
    "if input_parameters.dataset_name=='DayNight':\n",
    "    data_loader_caller=data_loader_DayNight('val')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.19270774722099304\n",
      "0.14638255536556244\n",
      "0.1411076784133911\n",
      "0.17821085453033447\n",
      "0.7251439094543457\n",
      "0.03943968936800957\n",
      "0.23542864620685577\n",
      "0.13249598443508148\n",
      "0.1584600955247879\n",
      "0.36716601252555847\n",
      "0.2669849693775177\n",
      "0.41034644842147827\n"
     ]
    }
   ],
   "source": [
    "total_error=0.0    \n",
    "\n",
    "fk_loop=input_parameters.num_iters\n",
    "\n",
    "\n",
    "for iters in range(10000000):\n",
    "    input_img,u_list,v_list,template_img=data_loader_caller.data_read_batch(batch_size=1)\n",
    "    if len(np.shape(input_img))<2:\n",
    "        break\n",
    "\n",
    "   \n",
    "\n",
    "    if input_parameters.initial_type=='simple_net':\n",
    "        input_img_grey=tf.image.rgb_to_grayscale(input_img)\n",
    "        template_img_new=tf.image.pad_to_bounding_box(template_img, 32, 32, 192, 192)  \n",
    "        template_img_grey=tf.image.rgb_to_grayscale(template_img_new)    \n",
    "        network_input=tf.concat([template_img_grey,input_img_grey],axis=-1)\n",
    "        homography_vector=regression_network.call(network_input,training=False)\n",
    "        extra=tf.ones((1,1))\n",
    "        initial_matrix=tf.concat([homography_vector,extra],axis=-1)\n",
    "        initial_matrix=tf.reshape(initial_matrix,[1,3,3])\n",
    "        initial_matrix=construct_matrix(initial_matrix,scale_factor=0.25,batch_size=1)\n",
    "\n",
    "    if input_parameters.initial_type=='multi_net':\n",
    "        input_img_grey=tf.image.rgb_to_grayscale(input_img)\n",
    "        template_img_new=tf.image.pad_to_bounding_box(template_img, 32, 32, 192, 192)  \n",
    "        template_img_grey=tf.image.rgb_to_grayscale(template_img_new)\n",
    "        network_input=tf.concat([template_img_grey,input_img_grey],axis=-1)\n",
    "        homography_vector_one=regression_network_one.call(network_input,training=False)\n",
    "        matrix_one=construct_matrix_regression(1,homography_vector_one)\n",
    "        template_img_new=LK_layer_regression.projective_inverse_warp(tf.dtypes.cast(template_img,tf.float32), matrix_one)\n",
    "        template_img_grey=tf.image.rgb_to_grayscale(template_img_new) \n",
    "        network_input=tf.concat([template_img_grey,input_img_grey],axis=-1)\n",
    "        homography_vector_two=regression_network_two.call(network_input,training=False)\n",
    "        matrix_two=construct_matrix_regression(1,homography_vector_one,homography_vector_two)\n",
    "        template_img_new=LK_layer_regression.projective_inverse_warp(tf.dtypes.cast(template_img,tf.float32), matrix_two)\n",
    "        template_img_grey=tf.image.rgb_to_grayscale(template_img_new)  \n",
    "        network_input=tf.concat([template_img_grey,input_img_grey],axis=-1)\n",
    "        homography_vector_three=regression_network_three.call(network_input,training=False)\n",
    "\n",
    "        extra=tf.ones((1,1))\n",
    "        initial_matrix=tf.concat([homography_vector_three,extra],axis=-1)\n",
    "        initial_matrix=tf.reshape(initial_matrix,[1,3,3])\n",
    "        initial_matrix=np.dot(initial_matrix[0,:,:], np.linalg.inv(matrix_two[0,:,:]))\n",
    "        initial_matrix=np.expand_dims(initial_matrix,axis=0)\n",
    "        initial_matrix=construct_matrix(initial_matrix,scale_factor=0.25,batch_size=1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        \n",
    "    input_feature_one=level_one_input.call(input_img,training=False)\n",
    "    template_feature_one=level_one_template.call(template_img,training=False)\n",
    "\n",
    "    input_feature_two=level_two_input.call(input_feature_one,training=False)\n",
    "    template_feature_two=level_two_template.call(template_feature_one,training=False)\n",
    "\n",
    "    input_feature_three=level_three_input.call(input_feature_two,training=False)\n",
    "    template_feature_three=level_three_template.call(template_feature_two,training=False)\n",
    "\n",
    "\n",
    "    if input_parameters.feature_map_type=='regular':\n",
    "        input_feature_map_one=input_feature_one\n",
    "        template_feature_map_one=template_feature_one\n",
    "\n",
    "        input_feature_map_two=input_feature_two\n",
    "        template_feature_map_two=template_feature_two\n",
    "\n",
    "        input_feature_map_three=input_feature_three\n",
    "        template_feature_map_three=template_feature_three\n",
    "\n",
    "    elif input_parameters.feature_map_type=='special':\n",
    "                \n",
    "        input_feature_map_one=calculate_feature_map(input_feature_one)\n",
    "        template_feature_map_one=calculate_feature_map(template_feature_one)\n",
    "\n",
    "        input_feature_map_two=calculate_feature_map(input_feature_two)\n",
    "        template_feature_map_two=calculate_feature_map(template_feature_two)\n",
    "\n",
    "        input_feature_map_three=calculate_feature_map(input_feature_three)\n",
    "        template_feature_map_three=calculate_feature_map(template_feature_three)\n",
    "        \n",
    "        \n",
    "    updated_matrix=initial_matrix\n",
    "    for j in range(fk_loop):\n",
    "        try:\n",
    "            updated_matrix=LK_layer_three.update_matrix(template_feature_map_three,input_feature_map_three,updated_matrix)\n",
    "        except:\n",
    "            print ('s')\n",
    "\n",
    "    updated_matrix=construct_matrix(updated_matrix,scale_factor=2.0,batch_size=1)\n",
    "    for j in range(fk_loop):\n",
    "        try:\n",
    "            updated_matrix=LK_layer_two.update_matrix(template_feature_map_two,input_feature_map_two,updated_matrix)\n",
    "        except:\n",
    "            print ('s')\n",
    "            \n",
    "    updated_matrix=construct_matrix(updated_matrix,scale_factor=2.0,batch_size=1)\n",
    "    for j in range(fk_loop):\n",
    "        try:\n",
    "            updated_matrix=LK_layer_one.update_matrix(template_feature_map_one,input_feature_map_one,updated_matrix)\n",
    "        except:\n",
    "            print ('s')\n",
    "\n",
    "\n",
    "\n",
    "    predicted_matrix=updated_matrix\n",
    "\n",
    "\n",
    "\n",
    "    cornner_error=average_cornner_error(1,predicted_matrix,u_list,v_list,top_left_u=0,top_left_v=0,bottom_right_u=127,bottom_right_v=127)\n",
    "\n",
    "    \n",
    "    print (np.float(cornner_error))\n",
    "    if iters>10:\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize feature maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(input_img[0,:,:,:])\n",
    "plt.show()\n",
    "plt.imshow(input_feature_map_one[0,:,:,0])\n",
    "plt.show()\n",
    "plt.imshow(template_img[0,:,:,:])\n",
    "plt.show()\n",
    "plt.imshow(template_feature_map_one[0,:,:,0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
